home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1995 #2 / Amiga Plus CD - 1995 - No. 2.iso / internet / faq / englisch / modula-3 < prev    next >
Encoding:
Text File  |  1995-04-11  |  65.5 KB  |  1,747 lines
  1. Archive-name: Modula-3-faq
  2.  
  3.  
  4.    
  5.    
  6.                                  MODULA-3 FAQ
  7.                                        
  8.    
  9.    
  10.    Michel Dagenais, dagenais@vlsi.polymtl.ca
  11.    
  12.    
  13.    
  14.    v2.5, 14 February 1995
  15.    
  16.    
  17.    
  18. Contents
  19.  
  20.      * Contents
  21.      * What is new?
  22.      * The language
  23.           + What is Modula-3?
  24.           + Is Modula-3 a superset of Modula-2?
  25.      * The documentation
  26.           + Where can I get a description of Modula-3? 
  27.           + Where can I get other information on Modula-3?
  28.      * The implementations
  29.           + Where can I get an implementation?
  30.           + What is SRC Modula-3?
  31.           + What is m3pc?
  32.      * Some specific questions
  33.           + Meeting with other Modula-3 users
  34.           + Why is "Hello World" so large?
  35.           + Why objects and interfaces?
  36.           + Comparisons between Modula-3 and other languages?
  37.           + What is the story with Trestle and OpenWindows?
  38.           + Linking with C++ code
  39.           + Flushing writers to see the output immediately
  40.           + Problems with threads and VTALARM
  41.           + What is the purpose of BRANDED and REVEAL
  42.           + Why uppercase keywords
  43.           + M3build versus Make or why m3 does not work
  44.           + Missing RTHooks or similar messages
  45.           + The program receives a SEGV signal under the debugger
  46.           + What is M3-lite, MS-Windows support
  47.           + Global Offset Table overflow on SPARC
  48.           + Exceptions raised by X or Network Objects applications
  49.           + X libraries not found
  50.      * FTP
  51.           + How To Obtain Pre-Compiled Binaries
  52.           + What if I don't have ftp access?
  53.      * Contributing
  54.           + Can I contribute Modula-3 software?
  55.           + ILU, an object-oriented multi-lingual RPC-capable module
  56.             system
  57.      * Modula-3 for teaching
  58.      * Modula-3 In Industry
  59.      * Work In Progress
  60.           + The SRC Compiler
  61.           + Integrated Development Environment
  62.           + Windowing And User Interfaces
  63.                o Rotated Text
  64.                o Postscript VBTs
  65.           + Persistence through reachability
  66.           + Abstract Syntax Tree Tools (M3 Parser)
  67.           + Computer Assisted Learning Tools (Algorithm Animation)
  68.           + Presentations, Tutorials And Teaching Material
  69.           + Reports And Books
  70.           + Parallel Programming
  71.      * Wish List
  72.           + M3Build
  73.           + Coverage And Performance Analysis
  74.           + More VBTs
  75.           + Distributed Computing (Network Objects)
  76.           + Interfaces To Other Libraries And Programs (Tcl, Dps...)
  77.      * Who's Who
  78.        
  79.   ABSTRACT:
  80.   
  81.    This document contains references to most of the material available on
  82.    the Modula-3 language, compiler, tools and libraries. It should
  83.    answer all the most frequently asked questions about Modula-3. The
  84.    FAQ was originally written by Eric Muller. Send corrections,
  85.    suggestions, additions to the current maintainer, Michel Dagenais
  86.    dagenais@vlsi.polymtl.ca.
  87.    
  88.    The postscript version is available on
  89.    ftp.vlsi.polymtl.ca:pub/m3/m3-faq.ps.
  90.    
  91.    An hypertext WWW version is found on
  92.    http://www.vlsi.polymtl.ca/m3/m3-faq.html.
  93.    
  94.    
  95.    
  96.    
  97.    
  98.                                 WHAT IS NEW?
  99.                                        
  100.    
  101.    
  102.    The SRC Modula-3 3.4 and 3.5 releases came out. Here is a list of the
  103.    new features:
  104.    
  105.      * new ports to IRIX 5.2, FreeBSD, and Windows/NT(w/o Trestle)
  106.      * a single top-level, build-everything m3makefile
  107.      * faster compilation (merged driver and pass0)
  108.      * runtime error message that include file and line number
  109.      * m3browser, an HTTP server that provides virtual Modula-3 space
  110.      * better shared library support for SOLsun and SPARC
  111.      * more robust type encodings for the debugger (but not Peter Klein's
  112.        changes)
  113.      * ParseParams and SLisp are back
  114.      * a floating-point version of the geometry package
  115.      * an untested Linux/ELF bootstrap
  116.      * a backend, m3cc, based on gcc 2.6.3
  117.      * a persistent objects library, stable, and stub generator,
  118.        stablegen.
  119.      * a simple drawing editor for Windows/NT.
  120.        
  121.    
  122.    
  123.                                 THE LANGUAGE
  124.                                        
  125.    
  126.    
  127. What is Modula-3?
  128.  
  129.    
  130.    
  131.    Modula-3 is a systems programming language that descends from Mesa,
  132.    Modula-2, Cedar, and Modula-2+. It also resembles its cousins Object
  133.    Pascal, Oberon, and Euclid.
  134.    
  135.    The goal of Modula-3 is to be as simple and safe as it can be while
  136.    meeting the needs of modern systems programmers. Instead of exploring
  137.    new features, they studied the features of the Modula family of
  138.    languages that have proven themselves in practice and tried to
  139.    simplify them into a harmonious language. They found that most of the
  140.    successful features were aimed at one of two main goals: greater
  141.    robustness, and a simpler, more systematic type system.
  142.    
  143.    Modula-3 retains one of Modula-2's most successful features, the
  144.    provision for explicit interfaces between modules. It adds objects and
  145.    classes, exception handling, garbage collection, lightweight processes
  146.    (or threads), and the isolation of unsafe features.
  147.    
  148. Is Modula-3 a superset of Modula-2?
  149.  
  150.    
  151.    
  152.    No; valid Modula-2 programs are not valid Modula-3 programs. However,
  153.    there is a tool to help convert Modula-2 programs to Modula-3.
  154.    
  155.                               THE DOCUMENTATION
  156.                                        
  157.    
  158.    
  159. Where can I get a description of Modula-3? 
  160.  
  161.    
  162.    
  163.    The language definition and most electronically available Modula-3
  164.    information can be accessed on
  165.    http://www.research.digital.com/SRC/modula-3/html/home.html.
  166.    
  167.    Modula-3 Home 
  168.    
  169.    Postscript versions of some of these documents, including the language
  170.    definition, are available from http://www.vlsi.polymtl.ca/m3/Doc.
  171.    
  172.    Postscript Modula-3 documents
  173.    
  174.    The definition of Modula-3 is contained in:
  175.    
  176.      * System Programming with Modula-3 Edited by Greg Nelson Prentice
  177.        Hall Series in Innovative Technology ISBN 0-13-590464-1 L.C.
  178.        QA76.66.S87 1991
  179.        
  180.    
  181.    
  182.    also known as SPwM3. Here is the table of contents:
  183.    
  184.     1. Introduction
  185.     2. Language Definition
  186.     3. Standard Interfaces
  187.     4. An Introduction to Programming with Threads
  188.     5. Thread Synchronization: A Formal Specification
  189.     6. I/O Streams: Abstract Types, Real Programs
  190.     7. Trestle Window System Tutorial
  191.     8. How the Language Got its Spots
  192.        
  193.    
  194.    
  195.    Chapters 2 and 3 have been reprinted in Sigplan Notices, Volume 27,
  196.    Number 8, August 1992, pp 15-42.
  197.    
  198.    Sam Harbison has written a more tutorial book about Modula3:
  199.    
  200.      * Modula-3 Samuel P. Harbison Prentice Hall, 1992 ISBN 0-13-596396-6
  201.        
  202.    
  203.    
  204.    The table of contents is as follows:
  205.    
  206.     1. Introduction
  207.     2. Declarations
  208.     3. Statements
  209.     4. Basic Types
  210.     5. Structured Types
  211.     6. Procedures
  212.     7. Exceptions
  213.     8. Interfaces and Modules
  214.     9. Generics
  215.    10. Dynamic Programming
  216.    11. Objects
  217.    12. Threads
  218.    13. Low-Level Programming
  219.    14. Programming Conventions
  220.    15. SRC Modula-3
  221.    16. Modula-3 Syntax
  222.    17. Answers to Selected Exercises
  223.        
  224.    
  225.    
  226.    The errata sheet is available via anonymous ftp from
  227.    gatekeeper.dec.com in pub/DEC/Modula-3/errata.
  228.    
  229.    Errata 
  230.    
  231.    If you cannot find these books at your favorite bookstore, here are
  232.    bookstores connected to the net known to carry them:
  233.    
  234.    UCI carries both books:
  235.    
  236.    UCI Bookstore 
  237.    
  238.    While Roswell is known to at least carry the language definition
  239.    (SPwM3):
  240.    
  241.    Roswell Electronic Computer Bookstore (rjames@fox.nstn.ns.ca)
  242.    
  243.    Roswell Bookstore 
  244.    
  245. Where can I get other information on Modula-3?
  246.  
  247.    
  248.    
  249.    There is a Usenet newsgroup, comp.lang.modula3. The archives of that
  250.    group are available via anonymous ftp from gatekeeper.dec.com in
  251.    pub/DEC/Modula-3/comp.lang.modula3. If you do not have access to
  252.    Usenet, there is a relay mailing list; send a message to
  253.    m3-request@src.dec.com to be added to it.
  254.    
  255.    Comp.lang.modula3 archive 
  256.    
  257.    There are a couple high-level overview articles available:
  258.    
  259.      * ``Introducing Modula-3'', Geoff Wyant, Linux Journal, December
  260.        1994.
  261.        
  262.        Paper in ftp.gte.com/pub/m3/linux-journal.html
  263.        
  264.      * ``Safe Programming with Modula-3'', Sam Harbison, Dr. Dobb's
  265.        Journal, Vol. 17, No. 10, October 1992, pp 88+.
  266.        
  267.      * ``Modula-3'', Sam Harbison, Byte, Vol. 15, No. 12, November 1990,
  268.        pp 385+.
  269.        
  270.    
  271.    
  272.    A description of the Modula-3 type system is in
  273.    
  274.      * ``The Modula-3 Type System'', Luca Cardelli, Jim Donahue, Mick
  275.        Jordan, Bill Kalsow, Greg Nelson, Conference Record of the
  276.        Sixteenth Annual ACM Symposium on Principles of Programming
  277.        Languages (POPL), Austin Texas, January 11-13 1989, pp 202-212.
  278.        
  279.    
  280.    
  281.    The Modula-3 treatment of floating-point values is described in
  282.    
  283.      * ``The Design of Floating-Point Data Types'', David Goldberg, ACM
  284.        Letters on Programming Languages and Systems (LOPLAS), June 1992,
  285.        Vol 1, no.2, pp 138-151
  286.        
  287.    
  288.    
  289.    The core library interfaces are described and indexed in
  290.    
  291.      * ``Some Useful Modula-3 Interfaces'', Jim Horning, Bill Kalsow,
  292.        Paul McJones, Greg Nelson, SRC Research Report 113. Available via
  293.        anonymous FTP from gatekeeper.dec.com in
  294.        pub/DEC/SRC/research-reports/SRC-113.ps.Z
  295.        
  296.        Libm3 
  297.        
  298.      * ``Pickles: a system for automatic serialization of typed values'',
  299.        Andrew Birrell, Greg Nelson, Susan Owicki, Edward Wobber, Systems
  300.        Research Center, Digital Equipment Corp., in preparation.
  301.        
  302.    
  303.    
  304.    The Trestle window system toolkit, higher-level FormsVBT toolkit, and
  305.    Zeus animation system available with Modula-3, are documented in the
  306.    following reports:
  307.    
  308.      * ``Trestle Reference Manual'', Mark S. Manasse and Greg Nelson, SRC
  309.        Research Report 68, December 1991.
  310.      * ``Trestle Tutorial'', Mark S. Manasse and Greg Nelson, SRC
  311.        Research Report 69, May 1, 1992.
  312.      * ``VBTkit Reference Manual: A toolkit for Trestle'', edited by Marc
  313.        H. Brown and James R. Meehan. (to be a SRC Research Report) A
  314.        draft version is available via anonymous FTP from
  315.        gatekeeper.dec.com in
  316.        pub/DEC/Modula-3/contrib/vbtkit.25Mar93.ps.Z.
  317.        
  318.        VBTKit 
  319.        
  320.      * ``The FormsVBT Reference Manual'', Marc H. Brown and James R.
  321.        Meehan, (to be a SRC Research Report). A draft version is
  322.        available via anonymous FTP from gatekeeper.dec.com in
  323.        pub/DEC/Modula-3/contrib/formsvbt.25Mar93.ps.Z and
  324.        pub/DEC/Modula-3/contrib/formsvbt.AppC.26Mar93.ps.Z.
  325.        
  326.        VBTKit library 
  327.        
  328.        VBTKit applications 
  329.        
  330.      * ``Zeus: A System for Algorithm Animation and Multi-View Editing'',
  331.        Marc H. Brown, SRC Research Report 75, February 28, 1992.
  332.        Available via anonymous FTP from gatekeeper.dec.com in
  333.        pub/DEC/SRC/research-reports/SRC-075*.ps.Z.
  334.        
  335.        Zeus 
  336.        
  337.      * ``Color and Sound in Algorithm Animation'', Marc H. Brown and John
  338.        Hershberger, SRC Research Report 76a, August 30, 1991. Available
  339.        via anonymous FTP from gatekeeper.dec.com in
  340.        pub/DEC/SRC/research-reports/SRC-076a*.ps.Z.
  341.        
  342.        Color and Sound 
  343.        
  344.      * ``The 1992 SRC Algorithm Animation Festival'', Marc H. Brown, SRC
  345.        Research Report 98, March 27, 1993. Available via anonymous ftp
  346.        from gatekeeper.dec.com in
  347.        pub/DEC/SRC/research-reports/SRC-098*.ps.Z.
  348.        
  349.        Animation Festival 
  350.        
  351.    
  352.    
  353.    Network objects are described in the following reports:
  354.    
  355.      * ``Network Objects'', Andrew Birrell, Greg Nelson, Susan Owicki,
  356.        and Edward Wobber, SRC Research Report 115, February 28, 1994.
  357.        Available via anonymous FTP from gatekeeper.dec.com in
  358.        pub/DEC/SRC/research-reports/SRC-115*.ps.Z.
  359.        
  360.        Network Objects 
  361.        
  362.      * ``Distributed garbage collection for Network Objects'', Andrew
  363.        Birrell, David Evers, Greg Nelson, Susan Owicki, and Edward
  364.        Wobber, SRC Research Report 116, December 1993. Available via
  365.        anonymous FTP from gatekeeper.dec.com in
  366.        pub/DEC/SRC/research-reports/SRC-116*.ps.Z.
  367.        
  368.        Distributed GC 
  369.        
  370.    
  371.    
  372.    While the Obliq embeddable interpreter is documented in:
  373.    
  374.      * ``Obliq: A lightweight language for network objects'', Luca
  375.        Cardelli, User's Manual, Systems Research Center, Digital
  376.        Equipment Corp., 1994. Available via anonymous FTP from
  377.        gatekeeper.dec.com in pub/DEC/Modula-3/contrib/Obliq.ps.
  378.        
  379.        Obliq 
  380.        
  381.    
  382.    
  383.    Hardcopy versions of these reports can be ordered by e-mail; send your
  384.    request including a postal mail address to src-reports@src.dec.com.
  385.    
  386.    SRC research reports 
  387.    
  388.    Sedgewick's classic text on computer algorithms is presented in
  389.    Modula-3 in:
  390.    
  391.      * Algorithms in Modula-3 Robert Sedgewick Addison-Wesley, 1993 ISBN
  392.        0-201-53351-0
  393.        
  394.    
  395.    
  396.                              THE IMPLEMENTATIONS
  397.                                        
  398.    
  399.    
  400. Where can I get an implementation?
  401.  
  402.    
  403.    
  404.    Two implementations are available, SRC Modula-3 and a PC version of it
  405.    (m3pc).
  406.    
  407.    As far as we know, implementations are not available for VMS,
  408.    Macintosh.
  409.    
  410. What is SRC Modula-3?
  411.  
  412.    
  413.    
  414.    SRC Modula-3 was built by the DEC Systems Research Center and is
  415.    available via anonymous ftp from gatekeeper.dec.com in
  416.    pub/DEC/Modula-3. In Europe it is also available from
  417.    ftp-i3.informatik.rwth-aachen.de in pub/Modula-3. The most recent
  418.    version is release 3.5.
  419.    
  420.    Recent releases are known to work on at least on the DS3100
  421.    (m3-request@src.dec.com), FreeBSD (Olaf Wagner olaf@logware.de), (HPPA
  422.    (laverman@cs.rug.nl), LINUX (dagenais@vlsi.polymtl.ca), NeXT 68000
  423.    (tom@smart.ruhr.de), (nayeri@gte.com) SPARC architectures. Work is
  424.    under way to port to OS/2 (Hendrik Boom hendrick@CAM.ORG and Craig
  425.    Andrew Kingston ckingsto@undergrad.math.uwaterloo.ca), AIX 3.2.5 for
  426.    RISC/6000 (Bob Barton barton@chopin.eche.ualberta.ca). The SPARC
  427.    release notes may be found on ftp.gte.com:pub/m3 while the LINUX ones
  428.    are available on ftp.vlsi.polymtl.ca:pub/m3/linux/README, the HPPA
  429.    notes are in ftp.vlsi.polymtl.ca:pub/m3/hppa/README, the FreeBSD notes
  430.    are in ftp.vlsi.polymtl.ca:pub/m3/freebsd/README.
  431.    
  432.    SRC-Modula-3 
  433.    
  434.    SPARC release notes 
  435.    
  436.    LINUX release notes 
  437.    
  438.    HPPA release notes 
  439.    
  440.    FreeBSD release notes 
  441.    
  442.    The compiler implements the language defined in SPwM3. There are
  443.    versions for the architectures listed below. While SRC can test on
  444.    DS3100, ALPHA/OSF, Windows NT and LINUX, it can only rely on what
  445.    users on other platforms tell them to integrate all the platform
  446.    specific code.
  447.    
  448.    Because of the improved portability of the 3.* release, ports to non
  449.    Unix platforms are easier. The Windows NT port, in progress, uses
  450.    native threads. This should be a good model for other implementations
  451.    of Thread using native threads.
  452.    
  453.      * AIX386: IBM PC running AIX/PS2,
  454.      * AOSF: DEC Alpha AXP running OSF/1
  455.      * AP3000: Apollo DN4500 running Domain/OS
  456.      * ARM: Acorn R260 running RISC iX 1.21
  457.      * DS3100: DECstation 3100 and 5000 running Ultrix 4.0 and 4.2
  458.      * HP300: HP 9000/300 running HP-UX 8.0
  459.      * HPPA: HP 9000/700, 9000/800 running HP-UX 8.0
  460.      * IBMR2: IBM R6000 running AIX 3.1,
  461.      * IBMRT: IBM RT running IBM/4.3,
  462.      * LINUX: Intel 386 running LINUX
  463.      * NEXT: NeXT running ??
  464.      * NT386: Intel 386 running Windows NT
  465.      * OKI: Okidata 7300 (i860) running UNIX SVR4.0
  466.      * SEQUENT: Sequent computers running ??
  467.      * SOL2: Sparc running Solaris 2.x
  468.      * SPARC: SPARCstation running SunOS 4.1.x
  469.      * SUN3: SUN3 running SunOS
  470.      * SUN386: Sun 386i running SunOS 4.0.1
  471.      * UMAX: Encore Multimax running UMAX 4.3 (R4.1.1)
  472.      * VAX: VAX running Ultrix 3.1
  473.        
  474.    
  475.    
  476.    The new native compiler is based on GCC and should be fairly easy to
  477.    port. Except for the very lowest levels of the thread implementation,
  478.    the entire system is written in Modula-3.
  479.    
  480.    The DEC SRC Modula-3 release 3.5 contains the following:
  481.    
  482.      * A native code compiler: uses the GCC backend; on
  483.        machines/operating systems that have self-describing stacks, an
  484.        optimized exception handling mechanism is provided, on other
  485.        architectures, setjmp/longjmp is used.
  486.        
  487.        The compilation system provides for minimal recompilation. Only
  488.        those units that depend on the modified interface item will be
  489.        recompiled.
  490.      * m3utils/m3build: tool that performs dependency analysis and builds
  491.        the Modula-3 programs and libraries.
  492.      * A large standard library (libm3) providing
  493.        
  494.           + A multithread, incremental, generational, conservative
  495.             garbage collector
  496.           + Text manipulation.
  497.           + Generic Containers: Lists, Sequences, Tables, SortedLists,
  498.             SortedTables
  499.           + Atoms and Symbolic expressions (Lisp like lists)
  500.           + An extensible stream IO system
  501.           + Typesafe binary object transcription (persistent objects)
  502.           + Operating system interfaces
  503.           + Portable interfaces to the language runtime
  504.    
  505.        
  506.        All standard libraries are thread-friendly. Modula-3 can readily
  507.        link with existing C libraries; many libraries including X11R4 and
  508.        various UNIX libraries are available as part of libm3.
  509.      * m3gdb: a Modula-3 aware version of GDB.
  510.      * trestle: a multi-threaded window system interface that sits on top
  511.        of X windows. It is not unlike InterViews and comes with several
  512.        sample programs.
  513.      * trestle/tcp: a library for simplified access to TCP/IP.
  514.      * vbtkit: a higher level toolkit on top of Trestle. It offers
  515.        buttons, menus, editors, file choosers... and has a Motif-like
  516.        look and feel.
  517.      * formsvbt: an interactive user interface builder. A symbolic
  518.        expression representing the user interface is edited and the
  519.        graphical view is immediately produced.
  520.      * tools/coverage: tool to determine the number of times each
  521.        statement is executed.
  522.      * tools/pp: pretty printer for Modula-3 programs.
  523.      * tools/gnuemacs: emacs lisp files to help editing and debugging
  524.        Modula-3 programs in emacs.
  525.      * tools/m3bundle: tool to bundle data files into an executable to
  526.        produce standalone programs.
  527.      * tools/m3totex: extract TeX documentation from Modula-3 programs
  528.        for a form of literate programming.
  529.      * tools/showheap: tool to graphically see the behavior of the
  530.        garbage collector.
  531.      * tools/shownew: tool to graphically see the allocation behavior of
  532.        a running program.
  533.      * tools/showthread: tool to see the activation of threads in a
  534.        running program.
  535.      * zeus: framework to develop graphical animations of algorithms
  536.        (heapsort, quicksort, LRU cache replacement, network protocols...)
  537.        for visualization and teaching purposes.
  538.      * mentor: a dozen of animations developed using Zeus.
  539.      * netobj: network objects that allow the transparent execution of
  540.        methods across process and machine boundaries. A simple yet very
  541.        effective way to build distributed applications.
  542.      * obliq: simple, interpreted, lexically scoped, object oriented,
  543.        distributed programming language that can be embedded in Modula-3
  544.        programs and call/be-called by Modula-3 procedures. The Obliq
  545.        object model is based on prototypes and delegation.
  546.      * A framework for parsing and analyzing Modula-3 programs. This is a
  547.        complete AST toolkit for Modula-3. This can parse arbitrary
  548.        Modula-3 sources (input isn't required to be a complete unit) and
  549.        produce detailed ASTs representing the input. The ASTs can be used
  550.        to do a variety of semantic analysis tasks, or program generation
  551.        tasks similar to Lisp environments. (m3tk).
  552.      * pkgtools/smalldb: library to store objects on disk with logging
  553.        and recovery capabilities.
  554.      * pkgtools: distribution tool that insures that several copies of a
  555.        package (software, document...) are updated simultaneously.
  556.      * postcard: mail and news reading environment.
  557.      * visualobliq: a graphical user interface builder coupled with a
  558.        simple yet powerful interpreted language, Obliq, for rapid
  559.        development of interactive distributed applications. This is a
  560.        rather new component and is undergoing a fair amount of evolution;
  561.        however, it is still very useful and exciting. Visual Obliq
  562.        provides an application builder similiar in nature to Visual
  563.        Basic. However, it uses Obliq as its scripting language. This
  564.        makes it easy to build and prototype interesting distributed and
  565.        groupware applications. It can be used for building
  566.        non-distributed applications as well.
  567.      * misc/tcl: interface to access the Tcl language from Modula-3.
  568.      * misc/dps: interface to access Display Postscript from Modula-3.
  569.      * games: more sample Trestle applications.
  570.        
  571.    
  572.    
  573. What is m3pc?
  574.  
  575.    
  576.    
  577.    A newer version of m3pc, code named EX32 in the README file, is
  578.    available via anonymous ftp from gatekeeper.dec.com in
  579.    pub/DEC/Modula-3/contrib/M3forDOS.
  580.    
  581.    PC Modula-3 
  582.    
  583.    From the README, written by Klaus Preschern:
  584.    
  585.    EX32 ("A 32-bit Extension of DOS") is a environment for the
  586.    developement and execution of 32-bit applications with DOS.
  587.    
  588.    EX32 is a collection of DOS programs (drivers + kernel). It provides
  589.    services for applications executed in protected mode. It does process
  590.    management, virtual memory management, interprocess communication via
  591.    pipes and it offers a file system with 32 character filenames.
  592.    
  593.    EX32 runs on MS-DOS 5.00, 6.00 and 6.02. You need a i386/i387
  594.    (coprocessor required) or upward (i486, Pentium). EX32 supports DOS
  595.    XMS memory (but not EMS, VCPI or DPMI). No support for the i286. You
  596.    should have at least 4 MB memory (8 MB or more recommended). The whole
  597.    package occupies unzipped and untared approximately 44 MB of disk
  598.    space.
  599.    
  600.    EX32 comes with GNU C++ (version 2.4.5), SRC Modula-3 (version 3.1,
  601.    including threads), two C libraries, a graphics library for VGA and a
  602.    number of commands (i.e. ls, cp, rm, mkdir, make, ...).
  603.    
  604.    Note: This is a system for experienced programmers! They should be
  605.    familiar with Unix and DOS.
  606.    
  607.                            SOME SPECIFIC QUESTIONS
  608.                                        
  609.    
  610.    
  611. Meeting with other Modula-3 users
  612.  
  613.    
  614.    
  615.    Modula-3 users meetings are held informally from time to time. A
  616.    report from the last meeting is available from
  617.    ftp://ftp.gte.com/pub/m3/m3ug/m3ug.html.
  618.    
  619.    Modula-3 users meeting
  620.    
  621. Why is "Hello World" so large?
  622.  
  623.    
  624.    
  625.    Modula-3 programs are larger than C programs for the following
  626.    reasons:
  627.    
  628.     1. The fixed runtime is substantially larger. It contains a garbage
  629.        collector, a thread runtime, and exception support. Note that
  630.        "Hello World" is virtually all runtime. For larger programs the
  631.        runtime is not an issue.
  632.     2. The generated code includes runtime checks for out-of-bound array
  633.        references and NIL pointer. Many of these checks could be removed
  634.        by a more sophisticated compiler.
  635.        
  636.    
  637.    
  638. Why objects and interfaces?
  639.  
  640.    
  641.    
  642.    Allan Heydon on comp.lang.modula3, May 4th 1993:
  643.    
  644.    Modula-3 provides two separate mechanisms for data-hiding: one for
  645.    hiding details about how interfaces are implemented, and the other for
  646.    hiding details about how objects are implemented.
  647.    
  648.    The first data-hiding mechanism is realized by the distinction between
  649.    interfaces and modules. Clients can only import interfaces, so the
  650.    names declared in the modules implementing those interfaces are hidden
  651.    from clients. Note that this mechanism has only two levels; a name is
  652.    either declared in an interface, or it isn't. If a name is only
  653.    declared in a module, it can't be used by a client.
  654.    
  655.    The second data-hiding mechanism is realized by opaque types and
  656.    revelations. A Modula-3 interface may declare an object type to be
  657.    opaque, in which case only a subset of the fields and methods of that
  658.    object are revealed to clients importing the interface. Furthermore,
  659.    the Modula-3 revelation mechanism allows a designer to reveal
  660.    successively more fields and methods of an object in a series of
  661.    interfaces. The fields and methods visible to a client then depends on
  662.    which interfaces the client imports.
  663.    
  664.    The latter mechanism is quite flexible. As opposed to the
  665.    interface/module data-hiding mechanism, opaque types allow you to
  666.    define an arbitrary number of levels at which more and more
  667.    information about the implementation of your object is revealed.
  668.    
  669.    See Sections 2.2.10, 2.4.6, and 2.4.7 of ``Systems Programming with
  670.    Modula-3" for more information about opaque types and about partial
  671.    and complete revelations.
  672.    
  673. Comparisons between Modula-3 and other languages?
  674.  
  675.    
  676.    
  677.    From: laszlo@post.ifi.uni-klu.ac.at (Laszlo BOESZOERMENYI)
  678.    
  679.    "A Comparison of Modula-3 and Oberon-2" by myself in "Structured
  680.    Programming" 1993, 14:15-22
  681.    
  682.    From: nayeri@gte.com
  683.    
  684.    Robert Henderson, Benjamin Zorn, A Comparison of Object-Oriented
  685.    Programming in Four Modern Languages, Department of Computer Science,
  686.    University of Colorado, Boulder, Colorado, Technical Report
  687.    CU-CS-641-93. Available by anonymous FTP and e-mail from
  688.    ftp.cs.colorado.edu in the file
  689.    pub/cs/techreports/zorn/CU-CS-641-93.ps.Z
  690.    
  691.    The paper evaluates Oberon, Modula-3, Sather, and Self in the context
  692.    of object-oriented programming. While each of these programming
  693.    languages provide support for classes with inheritance, dynamic
  694.    dispatch, code reuse, and information hiding, they do so in very
  695.    different ways and with varying levels of efficiency and simplicity. A
  696.    single application was coded in each language and the experience
  697.    gained forms the foundation on which the subjective critique is based.
  698.    
  699.    
  700. What is the story with Trestle and OpenWindows?
  701.  
  702.    
  703.    
  704.    Mark Manasse says:
  705.    
  706.    I think that the OpenWindows release should be enough (no need to get
  707.    the MIT X release), although there are a few things in Trestle that
  708.    trigger devastating bugs in OpenWindows. But the only library we
  709.    depend on is Xlib, R4 or later.
  710.    
  711.    The main thing I know that crashes OW 2.0 is the code where we call
  712.    GrabKey specifying AnyKey. You can either loop over all of the keys,
  713.    or you can just comment out the call; programs won't run exactly the
  714.    same, but you probably won't notice the difference.
  715.    
  716. Linking with C++ code
  717.  
  718.    
  719.    
  720.    Apparently there is no problem to call C++ functions declared as
  721.    extern "C".
  722.    
  723.    From: gwyant@cloyd.East.Sun.COM (Geoffrey Wyant - Sun Microsystems
  724.    Labs BOS)
  725.    
  726.    You must use your C++ compiler as the linker, rather than /bin/cc or
  727.    /bin/ld.
  728.    
  729.    You need to call the function '_main'. The easiest way to do this is
  730.    to have the following set of interfaces and implementations:
  731.    
  732.  
  733.         INTERFACE CXXMain;
  734.           <*EXTERN "_main"*> CxxMain;
  735.         END CXXMain;
  736.  
  737.         MODULE CXXMain;
  738.         BEGIN
  739.           CxxMain();
  740.         END;
  741.  
  742.    
  743.    
  744.    and then import CXXMain into your M3 main module. This will ensure
  745.    that the C++ function "_main" gets called.
  746.    
  747. Flushing writers to see the output immediately
  748.  
  749.    
  750.    
  751.    Modula-3 Writers are buffered. Thus, you need to issue a Wr.Flush when
  752.    the output should appear immediately, for instance to prompt the user
  753.    for some input. Since this can become annoying, libraries in other
  754.    languages sometimes offer the option of unbuffered writes. In
  755.    Modula-3, an equivalent behavior is obtained with AutoFlushWr which
  756.    gets a background thread to flush a writer at a specified interval.
  757.    
  758. Problems with threads and VTALARM
  759.  
  760.    
  761.    
  762.    The threads are implemented using the virtual timer interrupt.
  763.    Normally, the run time environment will catch the interrupt and
  764.    determine if thread switching is appropriate. However, if a new
  765.    process is created with fork, it will have the virtual timer activated
  766.    and no interrupt handler to receive it, resulting in a core dump. If
  767.    you use the standard procedure Process.Create to fork new processes,
  768.    this will be handled automatically for you. If you insist on using
  769.    fork, you need to disable the timer, fork and then reenable the timer.
  770.    
  771.    
  772. What is the purpose of BRANDED and REVEAL
  773.  
  774.    
  775.    
  776.    Allan Heydon writes:
  777.    
  778.    These two keywords are necessary because of two quite different
  779.    features of the language. REVEAL is necessary because Modula-3 has
  780.    opaque types and partial revelations. BRANDED is necessary because the
  781.    Modula-3 type system uses structural equivalence instead of name
  782.    equivalence.
  783.    
  784.    In Modula-3, the concrete structure of a type can be hidden from
  785.    clients in an interface. A common idiom is:
  786.    
  787.  
  788.   INTERFACE I;
  789.  
  790.   TYPE
  791.     T <: TPublic;
  792.     TPublic = OBJECT
  793.       (* fields *)
  794.     METHODS
  795.       (* methods *)
  796.     END;
  797.  
  798.   END I.
  799.  
  800.    
  801.    
  802.    The line "T <: TPublic" introduces the type "I.T" as an opaque subtype
  803.    of the type "I.TPublic". It does not reveal any of the other details
  804.    of the concrete structure of "I.T" to clients. Hence, "I.T" is said to
  805.    be an opaque type. Put another way, the structure of "I.T" is only
  806.    partially revealed to clients.
  807.    
  808.    In addition, it is possible to reveal more of "I.T"'s structure in
  809.    other interfaces, like this:
  810.    
  811.  
  812.   INTERFACE IRep;
  813.  
  814.   IMPORT I;
  815.  
  816.   TYPE
  817.     TPrivate = I.TPublic OBJECT
  818.       (* more fields *)
  819.     METHODS
  820.       (* more methods *)
  821.     END;
  822.  
  823.   REVEAL
  824.     I.T <: TPrivate;
  825.  
  826.   END IRep.
  827.  
  828.    
  829.    
  830.    This interface declares a type "IRep.TPrivate" that is a subtype of
  831.    "I.TPublic". It also asserts that "I.T" is also a subtype of
  832.    "IRep.TPrivate". A client that imports only the interface "I" has
  833.    access only to the fields and methods in "I.TPublic" when accessing an
  834.    object of type "I.T", but a client that imports both "I" and "IRep"
  835.    also has access to the fields and methods in "IRep.TPrivate" when
  836.    accessing an object of type "I.T".
  837.    
  838.    The "REVEAL" statement in this module simply asserts a subtype
  839.    relation. Unlike type declarations, revelations introduce no new
  840.    names. Hence, we could not have used the "TYPE" keyword in this case
  841.    because the type "I.T" has already been declared once (albeit
  842.    opaquely) in interface "I".
  843.    
  844.    Every opaque type must have a complete revelation. A complete
  845.    revelation has the form:
  846.    
  847.  
  848.   REVEAL
  849.     T = TConcrete;
  850.  
  851.    
  852.    
  853.    The revelation specifies that "TConcrete" is the concrete type for the
  854.    opaque type "T".
  855.    
  856.    The Modula-3 type system uses structural equivalence instead of name
  857.    equivalence. This means that two types are equal iff they have the
  858.    same structure. One consequence of this rule is that two types you
  859.    might intend to be distinct may actually be equal. This can have
  860.    unintended effects on the run-time behavior of your program. For
  861.    example, if both types that you expect to be distinct are actually
  862.    structurally equivalent and the two types guard two arms of a TYPECASE
  863.    statement, the arm for the second type will never be taken.
  864.    
  865.    If you want to avoid accidental equalities between two types, you can
  866.    brand one (or both) of them with the BRANDED keyword. A branded type
  867.    is equivalent to no other type, even if it is structurally equivalent
  868.    to some other type. In essence, the BRANDED keyword adds a bit of
  869.    virtual structure to the type that guarantees it will be distinct from
  870.    every other type.
  871.    
  872.    The Modula-3 syntax allows you to supply a text constant as a name for
  873.    the brand. If you don't supply an explicit brand, the compiler will
  874.    make one up; however, the implicit brand invented by the compiler is
  875.    not guaranteed to be chosen deterministically. Hence, explicit brands
  876.    are useful if you are communicating types from one process to another
  877.    and if you want to be sure that the branded type written by one
  878.    process matches the branded type read in by the other.
  879.    
  880.    Any two opaque types in a program must be distinct. Otherwise, it
  881.    would be too easy for clients to accidentally trip over type
  882.    collisions like the TYPECASE example mentioned above. To enforce the
  883.    restriction that all opaque types are distinct, the language requires
  884.    that the type "TConcrete" in the complete revelation above must be a
  885.    branded type.
  886.    
  887. Why uppercase keywords
  888.  
  889.    
  890.    
  891.    Some people prefer uppercase keywords others hate them. Another
  892.    possibility is to accept both forms for keywords. This topic has been
  893.    discussed at length and there is no solution that will completely
  894.    satisfy everyone's tastes. Fortunately this is a very minor issue and
  895.    you can easily have lowercase keywords automatically converted for you
  896.    using a macro package like m3su (pion.lcs.mit.edu:/pub/m3su) for
  897.    emacs.
  898.    
  899.    lowercase keywords macro
  900.    
  901. M3build versus Make or why m3 does not work
  902.  
  903.    
  904.    
  905.    The Modula-3 compiler m3 does a much finer grained dependency analysis
  906.    than possible with make. For this reason, a very flexible front end,
  907.    m3build, reads the program description files, m3makefile, and
  908.    generates the commands required to compile and link Modula-3 programs
  909.    and libraries. The m3makefile content is documented in the m3build
  910.    documentation. Calling the m3 compiler directly is difficult and thus
  911.    not recommended.
  912.    
  913. Missing RTHooks or similar messages
  914.  
  915.    
  916.    
  917.    The standard library, libm3, is not included by default. You need in
  918.    your m3makefiles to import(``libm3'') or to import a library which
  919.    imports libm3. Otherwise, messages about run time procedures such as
  920.    RTHooks not being available are produced.
  921.    
  922.    m3build
  923.    
  924. The program receives a SEGV signal under the debugger
  925.  
  926.    
  927.    
  928.    The garbage collector on some platforms uses the SEGV (segmentation
  929.    violation) signal to detect modified portions of the dynamically
  930.    allocated space. It is possible to disable this feature or to inform
  931.    the debugger to let these signals propagate. See the tips on how to
  932.    use the debugger.
  933.    
  934.    debugging
  935.    
  936. What is M3-lite, MS-Windows support
  937.  
  938.    
  939.    
  940.    M3-lite is a research project at DEC SRC to see how fast Modula-3
  941.    programs could be compiled and linked. It uses an integrated m3build,
  942.    m3 compiler and code generator (based on Burs) and is targeted at
  943.    Win32 (Windows NT or Windows Chicago). Research projects, by
  944.    definition, do not have release dates. Part of this work, when ready,
  945.    may also serve on other platforms, especially LINUX and FreeBSD since
  946.    they are intel based.
  947.    
  948. Global Offset Table overflow on SPARC
  949.  
  950.    
  951.    
  952.    From Sam Kendall (kendall@mv.mv.com):
  953.    
  954.    The problem: when I tried to m3build/m3ship netobj/stubgen I got the
  955.    following error during the linking process:
  956.    
  957.  
  958.   -> linking stubgen
  959.   ld: GLOBAL_OFFSET_TABLE overflown: need to use -PIC
  960.   Fatal Error: program "/bin/cc" failed, exit status = 1024
  961.   *** error code 1 (ignored)
  962.  
  963.    
  964.    
  965.    The solution: modify boot-SPARC/m3build/templates/SPARC to change two
  966.    occurrences of "pic" to "PIC". Also find the file
  967.    m3utils/m3build/templates/SPARC and change the following lines to have
  968.    "PIC" instead of "pic":
  969.    
  970.  
  971.   "-Y1@/bin/cc@-pic@",
  972.   "-Y6@" & LIB_USE & "/m3cgc1@-quiet@-fpic@",
  973.  
  974.    
  975.    
  976. Exceptions raised by X or Network Objects applications
  977.  
  978.    
  979.    
  980.    Graphical applications (based on Trestle/X Windows) raise the
  981.    TrestleComm.Failure exception when the DISPLAY environment variable is
  982.    incorrect or the X server is refusing the connection. They raise
  983.    MachineIDPosix.Failure if the network configuration files are
  984.    incorrectly set up, especially on LINUX; /etc/hosts must contain at
  985.    least a loopback address (127.0.0.1) and the /etc/rc scripts an
  986.    appropriate ifconfig command (/etc/ifconfig lo 127.0.0.1; /etc/route
  987.    add 127.0.0.1). Applications with Network Objects may also raise
  988.    exceptions or consume all the CPU time available when the network
  989.    configuration files are incorrect.
  990.    
  991. X libraries not found
  992.  
  993.    
  994.    
  995.    The position of X libraries is stored in, for instance for
  996.    pre-compiled LINUX binaries, the template file m3build/templates/LINUX
  997.    as well as in X11R4/LINUX/.M3EXPORTS. Thus you may want to edit these
  998.    files if your X libraries are located in an uncommon place.
  999.    
  1000.                                      FTP
  1001.                                        
  1002.    
  1003.    
  1004. How To Obtain Pre-Compiled Binaries
  1005.  
  1006.    
  1007.    
  1008.    The following binaries are available for FTP. If you are willing to
  1009.    provide binaries for other architectures, please contact
  1010.    dagenais@vlsi.polymtl.ca; they may be put on his FTP server or links
  1011.    to your server can be included in the FAQ. The full exploded source
  1012.    code tree is available along with the SPARC binaries.
  1013.    
  1014.      * Release 3.4 SPARC binaries. Contains most of the 3.4 release and
  1015.        comes with static and shared libraries. If you have problems
  1016.        building the 3.4 release for SPARC, you may want to look at the
  1017.        lude/modula3-3.4/src/poly directory as it contains all the locally
  1018.        modified files. The original source code is available in
  1019.        lude/modula3-3.4/src/orig and may be browsed to see examples of
  1020.        m3makefiles amd Modula-3 code. Requesting a directory with .tar.Z
  1021.        added to its name will automatically generate the corresponding
  1022.        compressed tar file.
  1023.        
  1024.        It can be retrieved from
  1025.        ftp.vlsi.polymtl.ca:lude/modula3-3.4/run/poly.tar.Z and should be
  1026.        placed in /usr/local/soft/modula3-3.4/run/poly... Then,
  1027.        /usr/local/soft/modula3-3.4/run/poly/sun4.1_sparc/bin must be
  1028.        added to your path. Compiled by Michel Dagenais.
  1029.        
  1030.        SPARC Modula3-3.4 
  1031.        
  1032.      * Release 3.4 LINUX binaries. It can be retrieved from
  1033.        ftp.vlsi.polymtl.ca:pub/m3/linux/src-m3-3.4l0.tar.gz and should be
  1034.        placed in /usr/local/soft/modula3-3.4... Then,
  1035.        /usr/local/soft/modula3-3.4/run/bin must be added to your path.
  1036.        Compiled by Michel Dagenais.
  1037.        
  1038.        LINUX Modula3-3.4 
  1039.        
  1040.      * Release 3.3 HPPA binaries. It can be retrieved from
  1041.        ftp.vlsi.polymtl.ca:pub/m3/hppa. Compiled by Bert Laverman.
  1042.        
  1043.        HPPA Modula3-3.3 
  1044.        
  1045.      * Release 3.3 68000 NeXT binaries. It can be retrieved from
  1046.        ftp.vlsi.polymtl.ca:pub/m3/next. Compiled by Thomas Neumann.
  1047.        
  1048.        NeXT Modula3-3.3 
  1049.        
  1050.      * Release 3.3 68000 FreeBSD binaries. It can be retrieved from
  1051.        ftp.vlsi.polymtl.ca:pub/m3/freebsd. Compiled by Olaf Wagner.
  1052.        
  1053.        FreeBSD Modula3-3.3 
  1054.        
  1055.    
  1056.    
  1057. What if I don't have ftp access?
  1058.  
  1059.    
  1060.    
  1061.    Unfortunately, DEC SRC cannot deliver Modula-3 other than by anonymous
  1062.    ftp.
  1063.    
  1064.    Fortunately, Prime Time Freeware (PTF) includes Modula-3. PTF is a set
  1065.    of two ISO-9660 CDroms filled with 3GB of freeware, issued
  1066.    semi-annually. The latest issue, Volume 1, Number 2, July 1992,
  1067.    contains SRC Modula-3 2.07. PTF is distributed via bookstores and
  1068.    mail. You can reach PTF using:
  1069.    
  1070.  
  1071.         Email:  ptf@cfcl.com
  1072.         Fax:    [1] (408) 738 2050
  1073.         Voice:  [1] (408) 738 4832
  1074.         Mail:   Prime Time Freeware
  1075.                 415-112 N. Mary Ave., Suite 50
  1076.                 Sunnyvale, CA 94086
  1077.                 USA
  1078.  
  1079.    
  1080.    
  1081.                                 CONTRIBUTING
  1082.                                        
  1083.    
  1084.    
  1085. Can I contribute Modula-3 software?
  1086.  
  1087.    
  1088.    
  1089.    Certainly. Send to m3-request@src.dec.com what you are willing to
  1090.    share, be it programs, libraries or other things. They will be put in
  1091.    the distribution.
  1092.    
  1093.    Right now, the pub/DEC/Modula-3/contrib directory contains:
  1094.    
  1095.    Contrib 
  1096.    
  1097.      * m3rpc a Sun RPC system from Xerox Parc
  1098.      * M2toM3 a translator from Modula-2 to Modula-3
  1099.      * m3pc an implementation of Modula-3 for PCs.
  1100.        
  1101.    
  1102.    
  1103.    You will also find on ftp.vlsi.polymtl.ca in pub/m3:
  1104.    
  1105.    Modula-3 contributions 
  1106.    
  1107.      * present-src-m3 slides for presenting the Modula-3 tools and
  1108.        libraries.
  1109.      * cache-anim a zeus graphical animation of the computer memory
  1110.        hierarchy.
  1111.      * realgeometry a floating point geometry package.
  1112.      * sequences sequences allowing insertions in the middle.
  1113.        
  1114.    
  1115.    
  1116.    And on ftp-i3.informatik.rwth-aachen.de:
  1117.    
  1118.    Modula-3 contributions 
  1119.    
  1120.      * m23gdb a newer version of m3gdb with important fixes for most
  1121.        platforms. Peter Klein writes: It is based on gdb 4.13 with
  1122.        enhancements from Cygnus, the Modula-3 support from the Modula-3
  1123.        3.3 release, and several patches by Oliver Meyer. It should work
  1124.        now with EPC Modula-2 2.0x and SRC Modula-3 3.3, at least on
  1125.        SPARC/SunOS 4.1.3. The Modula-3 support still isn't perfect, but a
  1126.        big improvement over SRC's distributed version. See the
  1127.        README.m23gdb file for details.
  1128.        
  1129.      * m2tom3. Peter Klein writes: m2tom3 is a system to port Modula-2
  1130.        programs to Modula-3. It consists of two parts: A conversion
  1131.        program which tries to create a Modula-3 source text with the same
  1132.        semantics as the Modula-2 input while retaining the original look
  1133.        and feel as good as possible. A base library which tries to
  1134.        emulate the Modula-2 standard library using the Modula-3 standard
  1135.        library.
  1136.        
  1137.      * Peter Klein writes: A demo version of the development environment
  1138.        we are working on in the ADT (Analysis and Development Tool)
  1139.        project is now available on our ftp server in
  1140.        pub/Modula-3-Contrib/adt.
  1141.        
  1142.    
  1143.    
  1144. ILU, an object-oriented multi-lingual RPC-capable module system
  1145.  
  1146.    
  1147.    
  1148.    The following was recently announced by Xerox PARC:
  1149.    
  1150.    Version 1.6.4 of the Xerox PARC Inter-Language Unification (ILU)
  1151.    system is now available for general use.
  1152.    
  1153.    WHAT'S ILU?
  1154.    
  1155.    ILU (pronounced eye'-loo) is a system that promotes software
  1156.    interoperability via interfaces. Interfaces between what? Whatever
  1157.    units of program structure are desired; we call them by the generic
  1158.    term "modules". They could be parts of one process, all written in the
  1159.    same language; they could be parts written in different languages,
  1160.    sharing runtime support in one memory image; they could be parts
  1161.    running in different memory images on different machines (on different
  1162.    sides of the planet). A module could even be a distributed system
  1163.    implemented by many programs on many machines. Calls across ILU
  1164.    interfaces involve only as much mechanism as necessary for the calling
  1165.    and called modules to interact. In particular, when the two modules
  1166.    are in the same memory image and use the same data representations,
  1167.    the calls are direct local procedure calls - no stubs or other RPC
  1168.    mechanisms are involved.
  1169.    
  1170.    ILU modules are known by their interfaces. A module interface is
  1171.    specified once in ILU's object-oriented Interface Specification
  1172.    Language (called, simply, ISL). For each of the particular programming
  1173.    languages supported by ILU (currently Common Lisp, ANSI C, C++, and
  1174.    Modula-3; Python, Tcl, and GNU Emacs-Lisp are in the works), a version
  1175.    of the interface in that particular programming language can be
  1176.    generated. The ILU kernel library provides services which may be used
  1177.    by the language-specific interface to overcome intermodule language or
  1178.    address space differences.
  1179.    
  1180.    GETTING THE RELEASE
  1181.    
  1182.    The release is only available via FTP from the PARC ftp server.
  1183.    Perhaps the simplest way is to go through our World Wide Web home
  1184.    page,
  1185.    
  1186.    ILU 
  1187.    
  1188.    CONTRIBUTORS
  1189.    
  1190.    Antony Courtney, Doug Cutting, Bill Janssen, Denis Severson, Mike
  1191.    Spreitzer, Mark Stefik, Farrell Wymore
  1192.    
  1193.                             MODULA-3 FOR TEACHING
  1194.                                        
  1195.    
  1196.    
  1197.    Modula-3 is very well suited for teaching: simple yet powerful, and
  1198.    safe. It avoids the complexity of legacy languages. It can be used to
  1199.    demonstrate modules and interfaces, object oriented programming,
  1200.    multi-threading (concurrency issues), graphical user interfaces
  1201.    (Trestle, VBTKit, FormsVBT) and even distributed programming (Network
  1202.    Objects, Obliq). Since less time is spent by students and teaching
  1203.    assistants chasing dangling pointers and corrupted data, more time is
  1204.    available for learning the important concepts.
  1205.    
  1206.    It is used for teaching in a number of universities. This list is far
  1207.    from complete, send corrections and additions to
  1208.    dagenais@vlsi.polymtl.ca.
  1209.    
  1210.    From: Carsten Whimster (bcrwhims@undergrad.math.uwaterloo.ca)
  1211.    
  1212.    University of Waterloo:
  1213.    
  1214.    CS246 - Third introductory course in computer science. Software
  1215.    engineering and software systems. Medium size projects. Uses Modula-3
  1216.    to demonstrate proper OO programming, as well as general programming
  1217.    practices.
  1218.    
  1219.    CS241 - Fourth and final intro course to CS. Focuses mainly on
  1220.    compilers and languages. Various assignments has students create most
  1221.    of the different parts of a compiler. Also introduces Scheme (lisp).
  1222.    
  1223.    From: Peter.Robinson@cl.cam.ac.uk
  1224.    
  1225.    University of Cambridge, England.
  1226.    
  1227.    The Computer Science course at the University of Cambridge teaches ML
  1228.    as an introductory language at the beginning of the freshman year, and
  1229.    then uses Modula-3 to develop imperative programming at the end of
  1230.    that year. Further lectures on advanced features of the language are
  1231.    given early in the second year, together with separate lectures on
  1232.    other, specialised languages.
  1233.    
  1234.    The course has been given to about 70 students each year since 1990,
  1235.    and has developed with the language. It ties in with other lectures on
  1236.    data structures and algorithms, software engineering and concurrency.
  1237.    Modula-3 is used for student group projects in the second year and for
  1238.    about a quarter of individual projects in the final year (where,
  1239.    interestingly, students using Modula-3 tend to earn higher grades than
  1240.    those using C/C++).
  1241.    
  1242.    Modula-3 is also used in the Computer Laboratory at Cambridge for a
  1243.    number of research projects on distributed computing, human-computer
  1244.    interaction and electronic CAD.
  1245.    
  1246.    From: Matthew.Huntbach@dcs.qmw.ac.uk
  1247.    
  1248.    We have used it for three years here at Queen Mary and Westfield
  1249.    College, London. The main problem I find with the language is the slow
  1250.    compilation speed on our teaching machines (Macs running A/UX),
  1251.    otherwise it's a nice language to teach with.
  1252.    
  1253.    From: laszlo@ifi.uni-klu.ac.at (Laszlo BOESZOERMENYI)
  1254.    
  1255.    University Klagenfurt
  1256.    
  1257.    Modula-3 is used at the following courses: Undergraduate:
  1258.    Softwaretechnology-1 (actually an introduction into programming) (on
  1259.    PCs) Softwaretechnology-2 (data structures and algorithms) (on PCs)
  1260.    Graduate: Computer Networks (on a network of DECs and SUNs) Parallel
  1261.    Programming (on an DEC-Alpha Farm)
  1262.    
  1263.    Modula-3 has been in use since ca. one year, with very good
  1264.    experiences.
  1265.    
  1266.    From: pk@i3.informatik.rwth-aachen.de (Peter Klein)
  1267.    
  1268.    Lehrstuhl fuer Informatik III, RWTH Aachen, Germany: Software
  1269.    Development Projects, now held for the second time using Modula-3. Aim
  1270.    of these projects is to introduce different aspects of software
  1271.    development to graduate students. This includes project planning,
  1272.    supervision, design, and cooperative implementation of small but
  1273.    usable software systems. Central ideas of software design and
  1274.    object-oriented implementation are presented and discussed with the
  1275.    concepts of Modula-3, which is also the implementation language.
  1276.    
  1277.    Future plans: Maybe Modula-3 will replace Modula-2 in some
  1278.    undergraduate programming lectures in the future.
  1279.    
  1280.    From: viggo@nada.kth.se
  1281.    
  1282.    Royal Institute of Technology. Several courses at the computer science
  1283.    department use Modula-3. The courses contain programming projects, and
  1284.    many students choose to use Trestle. (Dr. Viggo Kann,
  1285.    viggo@nada.kth.se)
  1286.    
  1287.    From: "Dave Snelling" (snelling@cs.man.ac.uk)
  1288.    
  1289.    Department of Computer Science, University of Manchester, Manchester
  1290.    U.K. We have a small, interdisciplinary collection of people using
  1291.    Modula-3 for a variety of activities. Our major production code is a
  1292.    hardware architecture simulator (about 120 modules). Smaller projects
  1293.    include a Lattice Gass model and a Shallow Water model.
  1294.    
  1295.    At: University of Massachusetts at Amherst
  1296.    
  1297.    Modula-3 is used as an input language for the Computer Science course
  1298.    on Compilation techniques. The professor is Eliot Moss.
  1299.    
  1300.    From: Michel Dagenais (dagenais@vlsi.polymtl.ca)
  1301.    
  1302.    Modula-3 is used as the main example in an undergraduate course on
  1303.    object oriented programming and in a graduate course on ``Algorithmic
  1304.    Aspects of CAD'', which includes a large portion on OO programming and
  1305.    databases.
  1306.    
  1307.    From: pbh@cs.sunysb.edu (Peter Henderson)
  1308.    
  1309.    Modula-3 is currently used for teaching Computer Science I and
  1310.    Computer Science II at SUNY at Stony Brook. We are currently
  1311.    developing a sequence of laboratory assignments and case studies
  1312.    introducing OO techniques and software reuse in these two courses.
  1313.    
  1314.    The first course for computer science majors at Stony Brook is
  1315.    "Foundations of Computer Science" which emphasizes general problem
  1316.    solving, mathematics and the relationships between mathematics and
  1317.    computer science. There is an extensive laboratory component using
  1318.    theorem provers, Prolog and Standard ML.
  1319.    
  1320.                             MODULA-3 IN INDUSTRY
  1321.                                        
  1322.    
  1323.    
  1324.    A number of programming teams in industry selected Modula-3 for their
  1325.    project. It encourages good programming practices and comes with
  1326.    excellent libraries for distributed programming and graphical user
  1327.    interfaces.
  1328.    
  1329.    From: gwyant@cloyd.East.Sun.COM (Geoffrey Wyant - Sun Microsystems
  1330.    Labs BOS)
  1331.    
  1332.    Sun Microsystems Laboratories, Inc. (East) is using Modula-3 (Network
  1333.    Objects, FormsVBT) as the basis for its research in large scale
  1334.    distributed object systems.
  1335.    
  1336.    From: Farshad Nayeri (nayeri@gte.com)
  1337.    
  1338.    Distributed Object Computing, GTE Labs, Waltham, Massachusetts USA
  1339.    Modula-3 (FormsVBT, Sx, Netobj libraries) is used to prototype
  1340.    distributed object management. (Farshad Nayeri nayeri@gte.com).
  1341.    
  1342.    Report 
  1343.    
  1344.                               WORK IN PROGRESS
  1345.                                        
  1346.    
  1347.    
  1348.    The purpose of this section is to let everyone know what is being
  1349.    worked on. This is not a commitment to a quick release or even to
  1350.    completion. However it may enable parties interested in the same
  1351.    topics to pool their efforts, avoid duplication or better integrate
  1352.    their packages.
  1353.    
  1354.    To find more information about the names mentioned, see the Who's Who
  1355.    section.
  1356.    
  1357. The SRC Compiler
  1358.  
  1359.    
  1360.    
  1361.    The compiler already implements the full language and runs on several
  1362.    platforms. Speed enhancements and support for some popular non-Unix
  1363.    platforms may be expected.
  1364.    
  1365. Integrated Development Environment
  1366.  
  1367.    
  1368.    
  1369.    A number of groups have made experiments in this area. Tools such as
  1370.    VBTkit for the user interface, m3tk for syntax and dependency
  1371.    analysis, dynamic linking... could be used to produce such an
  1372.    environment. It is worth noting that precompiled interfaces are much
  1373.    easier to achieve in M3 than in several other popular languages.
  1374.    
  1375.    Peter Klein is working on a Modula-3 development environment and
  1376.    associated user interface. See the paper entitled ``Designing Software
  1377.    with Modula-3'', it describes a software architecture description
  1378.    language based on Modula-3.
  1379.    
  1380.    Report ftp.informatik.rwth-aachen.de/pub/reports/1994/94-16.ps.gz
  1381.    
  1382.    Klaus Preschern, Carsten Weich, Laszlo Boszormenyi have made the port
  1383.    of Modula-3 to the PC. The M3-PC environment will be enhanced,
  1384.    especially with threads and graphics, including a student-friendly
  1385.    environment.
  1386.    
  1387.    David N. Gray of Lucid Inc. has been experimenting with connecting the
  1388.    Modula-3 compiler with the Lucid Energize Programming System
  1389.    (currently sold as a development environment for C and C++ on Sun
  1390.    SPARCstations). The modified compiler is available as an unsupported
  1391.    as-is hack, to accompany the new Energize release that it works with.
  1392.    
  1393.    Energize Modula-3
  1394.    
  1395.    Geoff Wyant is experimenting with FormsVBT/VBTKit to build a simple
  1396.    friendly development environment.
  1397.    
  1398. Windowing And User Interfaces
  1399.  
  1400.    
  1401.    
  1402.   ROTATED TEXT
  1403.   
  1404.    
  1405.    
  1406.    Currently, there is no VBT to show non horizontal text, because of X
  1407.    windows limitations. This would be desirable and can be implemented in
  1408.    one of the following ways: a) open a pipe to the ghostscript
  1409.    Postscript interpreter and use it as a font renderer, cache and
  1410.    display the character bitmaps produced; b) have Bezier curves for the
  1411.    most popular Postscript fonts, Trestle handles Bezier curves; c) use
  1412.    the new text facilities in X11R6 that remove previous limitations. A
  1413.    prototype implementation of a) has been implemented by Alain Dube
  1414.    (contact Michel Dagenais); the performance with the cache is good but
  1415.    this remains a relatively complex solution. The b) solution would be
  1416.    relatively easy to implement but the resulting quality may not be as
  1417.    good as a real font renderer. The c) solution may not be available for
  1418.    some time since many workstation vendors take a long time before
  1419.    integrating the new X windows facilities.
  1420.    
  1421.   POSTSCRIPT VBTS
  1422.   
  1423.    
  1424.    
  1425.    It is often useful to display Postscript files in a VBT, for example
  1426.    for an included diagram in a document editor.
  1427.    
  1428.    This can be achieved by using the ghostscript Postscript interpreter
  1429.    as a rasterizer. A prototype has been programmed by Alain Dube
  1430.    (contact Michel Dagenais) but the performance is not too good when
  1431.    large color bitmaps are handled. An alternative implementation is to
  1432.    convert Postscript files into display lists (Bezier curves and text)
  1433.    as a preprocessing step. Further displaying and even editing becomes
  1434.    very simple. A prototype implementation of this has been done by
  1435.    Benoit Poirier (contact Michel Dagenais).
  1436.    
  1437. Persistence through reachability
  1438.  
  1439.    
  1440.    
  1441.    Tony Hosking and Eliot Moss are working on persistent Modula-3
  1442.    objects. The main features are persistence through reachability, load
  1443.    on demand and a very low overhead for using persistent objects. The
  1444.    high performance is obtained by modifying the compiler and run-time.
  1445.    Initially a modified version of GCC, GNU M3, was being worked on.
  1446.    However, with the release of the SRC native compiler, the
  1447.    modifications are being moved to the SRC compiler instead.
  1448.    
  1449.    Persistency 
  1450.    
  1451. Abstract Syntax Tree Tools (M3 Parser)
  1452.  
  1453.    
  1454.    
  1455.    The m3tk library can be used to analyze Modula-3 source code in order
  1456.    to find specific constructions (use of OBSOLETE facilities, un-handled
  1457.    exceptions), build source code browser and analysis tools, stubs
  1458.    generators for network or persistent objects... Mick Jordan is working
  1459.    on the documentation, in his spare time.
  1460.    
  1461.    From: hudson@yough.ucs.umass.edu (Rick Hudson)
  1462.    
  1463.    If anyone is interested we have developed a Bison grammar that parses
  1464.    the Modula-3 language input. If interested please feel free to contact
  1465.    me hudson@cs.umass.edu.
  1466.    
  1467. Computer Assisted Learning Tools (Algorithm Animation)
  1468.  
  1469.    
  1470.    
  1471.    The Zeus Algorithm Animation package may be used to quickly develop
  1472.    graphical and animated teaching aids. Most of the algorithms described
  1473.    in Robert Sedgewick's Algorithms book have been animated at DEC SRC
  1474.    through the work of Marc H. Brown.
  1475.    
  1476.    Animation of compilation techniques have been produced by students at
  1477.    University of Illinois with the help of Marc Najork.
  1478.    
  1479.    From: "Arnulf Mester" (mester@ls4.informatik.uni-dortmund.de)
  1480.    
  1481.    As part of a studental project advised by a college of mine and me a
  1482.    Mentor-like collection of Zeus-based animations of typical distributed
  1483.    algorithms and communication protocols (termed ZADA) has been
  1484.    compiled. Hopefully I'll get to include more information and access
  1485.    during the next weeks into our ZADA WWW home page
  1486.    
  1487.    ZADA 
  1488.    
  1489. Presentations, Tutorials And Teaching Material
  1490.  
  1491.    
  1492.    
  1493.    Modula 3 is used for teaching in a number of Universities. Some
  1494.    Modula-3 related teaching material may be shared between interested
  1495.    parties.
  1496.    
  1497.    Michel Dagenais has a French presentation about the Modula 3 language
  1498.    that could be distributed.
  1499.    
  1500.    Geoff Wyant has prepared a tutorial on Modula-3 for OOPSLA.
  1501.    
  1502. Reports And Books
  1503.  
  1504.    
  1505.    
  1506.    Sam Harbison is preparing a revised version of his existing book on
  1507.    Modula-3. He may include more material on the new libraries.
  1508.    
  1509.    Laszlo Boszormenyi, Roland Mittermeir and Carsten Weich are working on
  1510.    a book (it will be published in German and in English) with the
  1511.    work-title:
  1512.    
  1513.    "Programming in Style - An Introduction into Programming with
  1514.    Modula-3"
  1515.    
  1516.    The book will be published at Springer (in German in October 1994, in
  1517.    English maybe or December, or January 1995). For the book, the M3-PC
  1518.    environment will be enhanced, especially with threads and graphics,
  1519.    including a student-friendly environment.
  1520.    
  1521.    From: BERGINF@PACEVM.DAC.PACE.EDU (Joseph Bergin)
  1522.    
  1523.    I am also at work on a Modula-3 college level textbook. It will cover
  1524.    the data structures course and will stress data abstraction. It will
  1525.    be similar to my current book: Data Abstraction: The Object-Oriented
  1526.    Approach using C++, published by McGraw Hill. Status: The software has
  1527.    been built and I am currently writing the text itself. Joe Bergin,
  1528.    berginf@pacevm.dac.pace.edu, Pace University
  1529.    
  1530. Parallel Programming
  1531.  
  1532.    
  1533.    
  1534.    From: Ernst A. Heinz, University of Karlsruhe, F.R. Germany (email:
  1535.    heinze@ira.uka.de)
  1536.    
  1537.    I would like to inform you about our ongoing Modula-3* project here at
  1538.    the University of Karlsruhe. At the moment, we are actively involved
  1539.    in adding sophisticated dependence and data flow analysis to DEC's
  1540.    Modula-3 compiler (release 3.x!). The Modula-3* compiler will be able
  1541.    to generate code for real parallel machines, for networks of
  1542.    workstations, and for standard sequential execution. (Our new IPD
  1543.    Modula-2* system available by anonymous ftp from ftp.ira.uka.de in
  1544.    "pub/programming/modula2star" may give you an initial feeling about
  1545.    it!)
  1546.    
  1547.    For all interested folks I have made my JSPP'93 paper publicly
  1548.    available by anonymous ftp. The title of the paper reads as follows:
  1549.    
  1550.    "Modula-3*: An Efficiently Compilable Extension of Modula-3 for
  1551.    Problem-Oriented Explicitly Parallel Programming".
  1552.    
  1553.    Paper 
  1554.    
  1555.    More recent work includes
  1556.    
  1557.    E.A. Heinz. Sequential and parallel exception handling in Modula-3*: A
  1558.    unifying semantics specification. In P. Schulthess (editor). Advances
  1559.    in Modular Languages: Proceedings of the Joint Modular Languages
  1560.    Conference, pages 31-49, Ulm, Germany, September 28-30, 1994.
  1561.    
  1562.    Paper 
  1563.    
  1564.                                   WISH LIST
  1565.                                        
  1566.    
  1567.    
  1568.    The Modula-3 development environment now contains a large number of
  1569.    very good tools and libraries that work nicely together. The purpose
  1570.    of this section is to help contributors determine what additions would
  1571.    be helpful to others. It may get you in contact with people that would
  1572.    like to use your contribution or with people that may provide some
  1573.    items on your wanted list or team with you for their development.
  1574.    
  1575. M3Build
  1576.  
  1577.    
  1578.    
  1579.    The descriptions of programs and libraries stored in m3makefiles are
  1580.    simple and efficient. It would be interesting to be able to specify
  1581.    different m3-options for some files (debugging, performance
  1582.    analysis...), and to have the dependency analysis take into account
  1583.    previously used options when determining modules to recompile (Michel
  1584.    Dagenais).
  1585.    
  1586.    Although makefiles cannot perform the same consistency checks as
  1587.    m3build and are more cumbersome to use, it may be useful to be able to
  1588.    drive the compiler through makefiles for training purposes (i.e. learn
  1589.    Modula-3 and Makefiles at the same time)
  1590.    (bwbecker@watdragon.uwaterloo.ca).
  1591.    
  1592. Coverage And Performance Analysis
  1593.  
  1594.    
  1595.    
  1596.    Tools already exist for coverage analysis, pretty printing,
  1597.    performance analysis, viewing the threads and the garbage collected
  1598.    heap. It would be nice to have these easily accessible through an
  1599.    integrated development environment (Michel Dagenais).
  1600.    
  1601. More VBTs
  1602.  
  1603.    
  1604.    
  1605.    An editor widget with multiple fonts (fixed and proportional character
  1606.    spacing) perhaps even with direct support for HTML (item lists,
  1607.    centered headings...) (Geoff Wyant, Farshad Nayeri).
  1608.    
  1609.    A diagram editor widget (Farshad Nayeri).
  1610.    
  1611.    A split VBT that positions NxM childs in aligned rows and columns
  1612.    (Geoff Wyant).
  1613.    
  1614.    A Graph VBT that displays arbitrary graphs (such as call trees, cross
  1615.    references...). This could be implemented adding a placement module
  1616.    (to determine the vertex positions) to work on the existing GraphVBT
  1617.    module (Geoff Wyant).
  1618.    
  1619.    Some of the VBTs implemented in miscellaneous libraries (such as
  1620.    GraphVBT in Mentor/Zeus) could be placed in a more visible location
  1621.    such as VBTKit (Michel Dagenais).
  1622.    
  1623.    MIME extensions to Postcard (Farshad Nayeri).
  1624.    
  1625.    Submit Trestle to a graphical designer (Farshad Nayeri).
  1626.    
  1627. Distributed Computing (Network Objects)
  1628.  
  1629.    
  1630.    
  1631.    Network objects are an exciting recent addition. The underlying model
  1632.    is very simple and effective. Authentication and access control will
  1633.    be required in many applications.
  1634.    
  1635.    A network object daemon that starts specific programs upon need, like
  1636.    inetd does using inetd.conf for most network services, would be very
  1637.    useful (Michel Dagenais).
  1638.    
  1639. Interfaces To Other Libraries And Programs (Tcl, Dps...)
  1640.  
  1641.    
  1642.    
  1643.    C functions are easily called from Modula 3. Thus, stubs have been
  1644.    produced to access John Ousterhout's Tcl and also Display Postscript
  1645.    from Modula 3.
  1646.    
  1647.    An automatic tool to produce such stubs from .h C files would be very
  1648.    useful (Geoff Wyant).
  1649.    
  1650.    Stubs to access the Motif X Windows library would be useful (Geoff
  1651.    Wyant).
  1652.    
  1653.    Similar stubs would be desirable to access databases such as Postgres
  1654.    or Exodus and access/provide World Wide Web information using the
  1655.    hypertext transfer protocol libraries (HTTP) (Geoff Wyant).
  1656.    
  1657.                                   WHO'S WHO
  1658.                                        
  1659.    
  1660.    
  1661.    Modula-3 enthusiasts, users or contributors. Please notify me for
  1662.    additions, corrections or removals.
  1663.    
  1664.      * Robert Ayers, Adobe, (ayers@Mv.Us.Adobe.Com), the Display
  1665.        Postscript to Modula-3 interface
  1666.      * Andrew Birrell, DEC SRC, (birrell@src.dec.com), Network objects.
  1667.      * Laszlo Boeszoermenyi, Universitaet Klagenfurt, Austria,
  1668.        (laszlo@ifi.uni-klu.ac.at), PC port (m3pc), Programming in style
  1669.        book.
  1670.      * Marc H. Brown, DEC SRC, (mhb@src.dec.com), VBTKit, FormsVBT, Zeus.
  1671.      * Luca Cardelli, DEC SRC, (luca@src.dec.com), Modula-3 definition,
  1672.        Obliq.
  1673.      * Michel Dagenais, Ecole Polytechnique de Montreal,
  1674.        (dagenais@vlsi.polymtl.ca), LINUX and SPARC M3 binaries, M3 FAQ.
  1675.      * John D. DeTreville, DEC SRC, (jdd@src.dec.com), Incremental
  1676.        garbage collector.
  1677.      * David N. Gray, Lucid Inc., Menlo Park, (gray@Lucid.Com), interface
  1678.        between the Lucid environment and the M3 compiler.
  1679.      * Sam Harbison, Tartan, harbison@tartan.com, Modula-3 book.
  1680.      * Ernst A. Heinz, University of Karlsruhe, F.R. Germany
  1681.        (heinze@ira.uka.de)
  1682.      * Allan Heydon, DEC SRC, (heydon@src.dec.com), IP, Lex, Fmt, PQueue,
  1683.        DblBufferVBT modules.
  1684.      * Jim Horning, DEC SRC, (horning@src.dec.com), Useful Modula-3
  1685.        interfaces.
  1686.      * Tony Hosking, Purdue University, (hosking@cs.purdue.edu),
  1687.        Persistent Modula-3.
  1688.      * Rick Hudson, University of Massachusetts at Amherst,
  1689.        (hudson@cs.umass.edu), GNU Modula-3.
  1690.      * Mick Jordan, Sunlabs near Palo Alto, mick.jordan@eng.sun.com,
  1691.        Modula-3 definition, M3TK and related tools.
  1692.      * Bill Kalsow, DEC SRC, (kalsow@src.dec.com), Modula-3 definition,
  1693.        M3 compiler and run-time.
  1694.      * Peter Klein, Lehrstuhl fuer Informatik III,
  1695.        (pk@i3.informatik.rwth-aachen.de). Modula-2 to Modula-3 converter,
  1696.        m3gdb improvements.
  1697.      * Bert Laverman, Groningen University, (laverman@cs.rug.nl), HPPA
  1698.        support.
  1699.      * Mark S. Manasse, DEC SRC, (msm@src.dec.com), Trestle.
  1700.      * Paul McJones, DEC SRC, (mcjones@src.dec.com), Useful Modula-3
  1701.        interfaces.
  1702.      * James R. Meehan, Adobe (jmeehan@mv.us.adobe.com), VBTKit,
  1703.        FormsVBT.
  1704.      * Roland Mittermeir, Universitaet Klagenfurt, Austria,
  1705.        (mittermeir@ifi.uni-klu.ac.at), Programming in style book.
  1706.      * Eliot Moss, University Of Massachusetts At Amherst,
  1707.        (moss@Cs.Umass.Edu), GNU Modula-3.
  1708.      * Eric Muller, DEC SRC (moved?), (muller@src.dec.com), M3 compiler
  1709.        and run-time.
  1710.      * Marc Najork, DEC SRC, (najork@src.dec.com), 3D animation.
  1711.      * Greg Nelson, DEC SRC, (gnelson@src.dec.com), Modula-3 definition,
  1712.        Systems Programming with Modula-3 book editor, Trestle, Network
  1713.        objects.
  1714.      * Farshad Nayeri, GTE Labs Near Boston, (nayeri@Gte.Com), m3-sparc
  1715.        mailing list.
  1716.      * Frode Odegard, (frode@Odegard.Com), commercial Modula-3 support.
  1717.      * Susan Owicki, Stanford University, (owicki@mojave.stanford.edu),
  1718.        Network objects.
  1719.      * Klaus Preschern, Universitaet Klagenfurt, Austria,
  1720.        (preschern@ifi.uni-klu.ac.at), PC port (m3pc).
  1721.      * Robert Sedgewick, Princeton University, Algorithms in Modula-3
  1722.        book.
  1723.      * Jorge Stolfi, University of Campinas, Brazil,
  1724.        (stolfi@dcc.unicamp.br), Computational geometry procedures.
  1725.      * Carsten Weich, Universitaet Klagenfurt, Austria,
  1726.        (weich@ifi.uni-klu.ac.at), PC port (m3pc), Programming in style
  1727.        book.
  1728.      * Edward Wobber, DEC SRC, (wobber@src.dec.com), Network objects.
  1729.      * Geoff Wyant, Sunlabs Near Boston, (gwyant@East.Sun.COM), SPARC
  1730.        port.
  1731.        
  1732.    
  1733.    
  1734.    
  1735.      _________________________________________________________________
  1736.    
  1737.    
  1738.    
  1739.     Michel Dagenais, dagenais@vlsi.polymtl.ca, Mon Feb 13 14:20:30 EST
  1740.     1995
  1741. --
  1742.  
  1743. Prof. Michel Dagenais        http://www.vlsi.polymtl.ca/dagenais/home/home.html
  1744. Dept of EE and Computer Eng.        dagenais@vlsi.polymtl.ca
  1745. Ecole Polytechnique de Montreal     tel: (514) 340-4029
  1746.  
  1747.